package com.loong.android.tools;

/**
 * 多线程工具类
 */
public class Thread {
    private java.lang.Thread mThread;

    public Thread() {

    }

    public Thread(java.lang.Thread thread) {
        this.mThread = thread;
    }

    public Thread setThread(java.lang.Thread thread) {
        this.mThread = thread;
        return this;
    }

    public java.lang.Thread getThread() {
        return mThread;
    }

    /**
     * 创建线程，每次创建，都会重新创建一个java.lang.Thread实例
     * 若之前已经创建过，则原来创建的java.lang.Thread实例将被覆盖掉，
     * 重复创建时，需要先妥善处理之前创建的实例。
     *
     * @param event 线程运行回调
     * @return 返回创建的java.lang.Thread实例。也可以在创建后，通过{@link #getThread}方法获取
     */
    public java.lang.Thread create(RunEvent event) {
        mThread = new java.lang.Thread(() -> {
            if (event != null) event.onRun();
        });
        return mThread;
    }

    /**
     * 启动线程
     */
    public void start() {
        mThread.start();
    }

    /**
     * 当前所处的线程 等待 操作的线程执行完毕
     * 注意: 如果此函数用在主线程, 将使阻塞主线程
     */
    public void join() throws InterruptedException {
        mThread.join();
    }

    /**
     * 当前所处的线程 等待 操作的线程执行完毕
     * 注意: 如果此函数用在主线程, 将使阻塞主线程
     * @param timeout 超时，单位为毫秒
     */
    public void join(long timeout) throws InterruptedException {
        mThread.join(timeout);
    }

    /**
     * 当前所处的线程 等待 操作的线程执行完毕
     * 注意: 如果此函数用在主线程, 将使阻塞主线程
     * @param timeout 超时，单位为毫秒
     * @param nanos 0-999999 额外的纳秒等待
     */
    public void join(long timeout, int nanos) throws InterruptedException {
        mThread.join(timeout, nanos);
    }

    /**
     * 取线程id
     */
    public long getId() {
        return mThread.getId();
    }

    /**
     * 设置名称
     * @param name 名称
     */
    public void setName(String name) {
        mThread.setName(name);
    }

    /**
     * 取名称
     */
    public String getName() {
        return mThread.getName();
    }

    /**
     * 取优先级
     */
    public int getPriority() {
        return mThread.getPriority();
    }

    /**
     * 判断此线程是否存在。 如果线程已启动且尚未死亡，则该线程处于活动状态
     */
    public boolean isAlive() {
        return mThread.isAlive();
    }

    /**
     * 判断此线程是否为守护线程
     */
    public boolean isDaemon() {
        return mThread.isDaemon();
    }

    /**
     * 判断此线程是否已被中断。线程的中断状态不受此方法的影响。
     * 由于在中断时线程不活动而被忽略的线程中断将通过此方法返回 false 来反映。
     */
    public boolean isInterrupted() {
        return mThread.isInterrupted();
    }

    /**
     * 返回此线程的字符串表示形式，包括线程的名称、优先级和线程组
     */
    public String toString() {
        return mThread.toString();
    }

    /**
     * 使当前线程交出CPU，让CPU去执行其他的任务，但不会是线程进入阻塞状态，而是重置为就绪状态，yield方法不会释放锁
     * （yield并不意味着退出和暂停，只是，告诉线程调度如果有人需要，可以先拿去，我过会再执行，没人需要，我继续执行）
     */
    public static void yield() {
        java.lang.Thread.yield();
    }

    /**
     * 使线程休眠指定的时间
     * @param millis 时间，单位为毫秒
     * @throws InterruptedException
     */
    public static void sleep(long millis) throws InterruptedException {
        java.lang.Thread.sleep(millis);
    }

    /**
     * 获取当前线程的对象
     */
    public static Thread currentThread() {
        return new Thread(java.lang.Thread.currentThread());
    }

    public static java.lang.Thread getCurrentOriginThread() {
        return java.lang.Thread.currentThread();
    }

    /**
     * 判断当前线程是否被中断。 通过该方法清除线程的中断状态。
     * 换句话说，如果这个方法被连续调用两次，第二次调用将返回 false（除非当前线程再次被中断，在第一次调用清除其中断状态之后，第二次调用检查它之前）。
     * 由于在中断时线程不活动而被忽略的线程中断将通过此方法返回 false 来反映
     * @return 如果当前线程已被中断，则为 true，否则为假
     */
    public static boolean interrupted() {
        return java.lang.Thread.interrupted();
    }

    /**
     * 当且仅当当前线程持有指定对象上的监视器锁时才返回 true。
     * 此方法旨在允许程序断言当前线程已经持有指定的锁
     * @param obj 测试锁所有权的对象
     * @return 如果当前线程持有指定对象的监视器锁，则为 true
     */
    public static boolean holdsLock(Object obj) {
        return java.lang.Thread.holdsLock(obj);
    }

    /**
     * 返回当前线程的线程组及其子组中活动线程数的估计值。 递归迭代当前线程的线程组中的所有子组。
     * 返回的值只是一个估计值，因为在此方法遍历内部数据结构时线程数可能会动态变化，并且可能会受到某些系统线程的存在的影响。
     * 此方法主要用于调试和监视目的
     * @return 当前线程的线程组和以当前线程的线程组为祖先的任何其他线程组中的活动线程数的估计
     */
    public static int activeCount() {
        return java.lang.Thread.activeCount();
    }

    /**
     * 多线程的接口事件
     */
    public abstract static class RunEvent {
        /**
         * 多线程运行过程回调
         */
        public void onRun() {
        }
    }

    /**
     * 优先级表
     */
    public static class Priority {
        //最小优先级
        public final static int MIN = java.lang.Thread.MIN_PRIORITY;
        //正常优先级
        public final static int NORM = java.lang.Thread.NORM_PRIORITY;
        //最大优先级
        public final static int MAX = java.lang.Thread.MAX_PRIORITY;
    }
}
